\documentclass[10pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}             
\usepackage{lmodern}
\usepackage{xcolor}
\usepackage[francais]{babel}
\usepackage{verbatim}
\usepackage{listingsutf8}
\usepackage{graphicx}
\usepackage[final]{pdfpages} 
\usepackage{version}
\usepackage{textcomp}
\lstset{
	%language=php,
	breaklines=true,
	%inputencoding=utf8/latin1,
	%basicstyle=\footnotesize,
   % emph=[1]{php},
   %emph=[2]{if,and,or,else},
   %tabsize=1
}

\title{}

\begin{document}
\includepdf[pages=1]{Bredele_Thesis.pdf}
\newpage
\tableofcontents
%Pour modifier les remerciement, modifier remerciement.tex
\newpage
\section*{Remerciement}

Nous voudrions avant tout remercier notre tuteur, Monsieur Michel MEYNARD pour nous avoir accompagné durant ce parcours qui aura duré tout le Semestre 6. Son aide a été très précieuse afin de nous guider.
Et bien sûr nous remercions également la Faculté des Sciences de nous avoir permis de réaliser notre projet.


\newpage
\section*{Introduction}
Dans le cadre de l’unité d’enseignement de Projet du semestre 6 de la troisième année de licence informatique à la Faculté des Sciences de Montpellier, nous réalisons le remaniement du site de gestion de projet de M. Michel Meynard. Il s'agit d'améliorer le site, de le "nettoyer" et de le rendre plus cohérent face au modèle MVC.\newline
Nous disposions du code du site actuel en ligne et après analyse de celui-ci, nous avons décidé de re-penser l'architecture du site tout en gardant les fonctionnalités de l'original.\\
Nous allons donc présenter la résultante de ce projet en commençant par l'analyse du cahier des charges, les conclusions, choix logiques et technologiques qui en ont découlés.\\
Puis nous présenterons rapidement les technologies utilisées pour répondre à cette demande et enfin nous expliquerons les différentes parties de la phase programmation.
\newpage
\section{Cahier des charges}
\subsection{Présentation du sujet et analyse du contexte}

Le projet est un site de gestion de projet. Le but du site est que l'administrateur enregistre ses étudiants, les répartissent par projet et les notes. Il faut aussi gérer les soutenances. Certaines parties du site sont visibles par les étudiants, ou les tuteurs. Ce site doit permettre à un administrateur de gérer son site, mais il doit aussi permettre l’accès à la secrétaire, les étudiants, ou les tuteurs de projet.\\
Nous commençons l'analyse avec le code du site actuel.\newline
%%Nous avons décidé de le réaliser principalement en PHP car cela nous permet d’utiliser le framework Symfony afin de faciliter et accélérer le développement  du travail et de mettre en place une maintenance durable.

\subsection{Analyse de l'existant}
\subsubsection{Analyse des besoins fonctionnels}

% Mettre nos analyse  de code ??
Voici le schéma de la base de données du site existant, déduit de l'analyse du code.\newline \newline
\includegraphics[scale=0.5]{diagbddancien.png}
\newpage
\begin{enumerate}
\item \textbf{Fonctionnalités obligatoires}\newline \newline
D'après le code du site actuel, nous avons dégagé les fonctionnalités suivantes :\newline
\textbf{Pour tout utilisateur :}
\begin{itemize}
\item s’authentifier : lors de l'inscription, l'utilisateur à un type qui lui est attribué (étudiant, tuteurs ou admin ), qui lui autorise ou interdit l'accès à certaines fonctionnalités.
\item voir le planning de soutenance 
\item contacter l’administrateur du site : grâce à son adresse mail.\newline
\end{itemize}

\textbf{Pour l’administrateur :}
\begin{itemize}
\item gérer les permissions des utilisateurs : autoriser les élèves à réaliser leurs vœux, par exemple.
\item ajout des utilisateurs
\item admission et répartition des élèves dans les projets 
\item modifier son mot de passe
\item créer projet
\item modifier son e-mail\newline
\end{itemize}



\textbf{Pour la secrétaire :}
\begin{itemize}
\item accéder et modifier le planning de soutenance\newline
\end{itemize}


\textbf{Pour l’utilisateur authentifié étudiant :}
\begin{itemize}
\item voir la liste des projets
\item choisir et ranger ses choix de projet
\item modifier ses choix
\item voir la liste des affectations 
\item changer de mot de passe
\item changer l’e-mail 
\item choisir son UE\newline	
\end{itemize} 

\textbf{Pour le tuteur :}
\begin{itemize}
\item Créer des projets
\item Modifier ses projets
\item Mise à jour du mot de passe et des mails\newline
\end{itemize}

Les principales fonctionnalités précédentes ont été modélisées pour chaque “type” d’utilisateurs (étudiant, tuteurs, administrateur, secrétaire).\newline

Modélisation des cas d’utilisation pour utilisateur (obligatoires) :\newline
\includegraphics[scale=0.5]{usecase2.jpg}\newline
Modélisation des cas d’utilisation pour l’administrateur (obligatoires) :\newline
\includegraphics[scale=0.5]{usecase6.jpg}
\newpage
Modélisation des cas d’utilisation pour le tuteur (obligatoires) :\newline
\includegraphics[scale=0.5]{usecasetuteur.jpg}\newline
Modélisation des cas d’utilisation pour l’étudiant (obligatoires) :\newline
\includegraphics[scale=0.5]{usecase1.jpg}\newline \newpage
Modélisation des cas d’utilisation pour la secrétaire (obligatoires) :\newline
\includegraphics[scale=0.5]{usecase4}\newline \newline
 
\item \textbf{Fonctionnalités optionnelles}\newline \newline
%TODO Facebook 
Nous proposons d’ajouter une possibilité d’ajout d’un rapport pour chaque projet et un espace dédié aux utilisateurs : cet espace sera utilisé pour la communication entre membre d’un groupe de projet.\\
Voici un usecase avec les nouveautés proposées.\newline
\includegraphics[scale=0.5]{usecase3.jpg}\newline
 Le but est de faciliter la communication entre collègues. Il permettra, par exemple, de créer un groupe Facebook du nom du projet, et d’avoir une correspondance des messages, une mise à jour, entre la page du site de gestion de projet et le groupe Facebook.\\
 On pourra échanger des messages et partager des documents.
Cela permettra des synthèses des réunions, de suivre l’avancement du projet et d’avoir un “journal de bord”.
\end{enumerate}

\subsubsection{Spécifications techniques} 

%TODO : pourquoi tout ca en fonction des besoins de l'analyse

Voici la technologie utilisée par M.Meynard sur le site actuel.\newline
\begin{enumerate}
\item  \textbf{PHP} : Hypertext Preprocessor est un langage de programmation libre, principalement utilisé pour produire des pages Web dynamiques via un serveur HTTP, mais fonctionnant également comme n'importe quel langage interprété de façon locale. PHP est un langage impératif orienté-objet et la syntaxe du langage a de nombreuses origines, notamment celles du  C, du Perl et de Java. Il est utilisé ici pour créer les pages web, les sessions, ect. \newline

  Le \textbf{PHP} a plusieurs atouts :
  \begin{itemize}
  \item Une grande communauté de développeurs partageant des centaines de milliers d'exemples de script PHP ;
  \item La gratuité et la disponibilité du code source (PHP est distribué sous licence GNU GPL) ;
  \item La simplicité d'écriture de scripts ;
  \item La possibilité d'inclure le script PHP au sein d'une page HTML ;
  \item La simplicité d’interfaçage avec des bases de données (principalement MySQL) ;
  \item L'intégration au sein de nombreux serveurs web (Apache, Microsoft IIS, etc.)\newline
  \end{itemize}

\item  \textbf{HTML} : HyperText Mark-Up Language est un langage dit de balisage (utilisation de balises) conçu pour l'écriture et la représentation d'une page Web. Les balises permettent d'indiquer la façon dont doit être présenté le document et les liens qu'il établit avec d'autres documents. Le \textbf{HTML} permet d’écrire de l’hypertexte (système contenant des nœuds liés entre eux par des hyperliens). \textbf{HTM}L permet également de structurer sémantiquement et de mettre en forme le contenu des pages, d’inclure des ressources multimédias dont des images, des formulaires de saisie, et des programmes informatiques. Il est souvent utilisé conjointement avec des langages de programmation (\textbf{PHP}, \textbf{JavaScript}) et des formats de présentation \textbf{CSS} (feuilles de style en cascade). Nous utiliserons la dernière version de HTML : \textbf{HTML5}.\newline

\item \textbf{CSS} : Cascading StyleSheets (feuilles de style en cascade) : les feuilles de style forment un langage informatique qui décrit la présentation des documents \textbf{HTML} et \textbf{XML}. Elles ont été mises au point afin de compenser les manques du langage \textbf{HTML} en ce qui concerne la mise en page et la présentation. En effet, le \textbf{HTML} offre un certain nombre de balises permettant de mettre en page et de définir le style d'un texte, toutefois chaque élément possède son propre style, indépendamment des éléments qui l'entourent. Grâce aux feuilles de style, lorsque la charte graphique d'un site composé de plusieurs centaines de pages web doit être changée, il suffit de modifier la définition des feuilles de style en un seul endroit pour changer l'apparence du site tout entier.\newline

  Les feuilles de style servent notamment à:
  \begin{itemize}
  \item obtenir une présentation homogène sur tout un site en faisant appel sur toutes les pages à une même définition de style ;
  \item permettre le changement de l'aspect d'un site complet entier par la seule modification de quelques lignes ;
  \item une plus grande lisibilité du \textbf{HTML}, car les styles sont définis à part ;
  \item des chargements de page plus rapides, pour les mêmes raisons que précédemment ;
  \item un positionnement plus rigoureux des éléments.\newline
  \end{itemize}
  
%% \item \textbf{Symfony} : c'est un framework (boîte à outils) \textbf{MVC} (Modèle-Vue-Contrôleur) libre écrit en \textbf{PHP} 5. 
%%   En tant que framework, il facilite et accélère le développement de sites et d'applications Internet et Intranet.
%%   Il permet par exemple, d'améliorer la productivité des développeurs qui l'utilisent. Il est très pratique lorsque l'on travaille en groupe car il pose une structure et des conventions qui permettent une meilleure lisibilité entre collaborateurs. Il gère également seul l'architecture \textbf{MVC} en séparant le \textbf{PHP} du \textbf{HTML}.\newline

%%   Les atouts de Symfony :
%%   \begin{itemize}
%%   \item le code est découplé;
%%   \item la séparation application / module permet de personnaliser facilement de nombreux paramètres;
%%   \item meilleure lisibilité du code;
%%   \item une API;
%%   \item des feuilles de résumé (cheat sheets);
%%   \item importante communauté d'utilisateurs et tutoriels de référence.\newline
%%   \end{itemize}

%% \item  \textbf{Doctrine} :  il s'agit d’un \textbf{ORM} (mapping objet-relationnel) pour le \textbf{PHP}. Un \textbf{ORM}  est une technique permettant de lier un ensemble de classes objet à une base de données relationnelle. Il peut s'utiliser avec Symfony et \textbf{Symfony2}. Nous l'avons choisi au détriment de Propel car celui ci est amené à disparaître dans les prochaines versions de Symfony.\newline

\item \textbf{Propel} : Propel est un ORM (Object-Relational Mapping) c'est à dire qu'il permet de gérer la base de donnée comme si elle contenait des objets. On a créer la base de données à partir d'une correspondance objet et relation. Il sert ici à dessiner la base de données.

\item \textbf{MySQL} : c’est un système de gestion de base de données (SGBD). Il est distribué sous une double licence GPL et propriétaire. Il fait partie des logiciels de gestion de base de données les plus utilisés au monde, autant par le grand public (applications web principalement) que par des professionnels. Il stocke les données concernant les étudiants et les tuteurs.
\end{enumerate}

\subsection{Analyse du futur site}
%usecase, facebook
Le site devra évidemment avoir toutes les fonctionnalités obligatoires détaillées ci-dessus. Pour ce faire, nous utiliserons les use cases.\newline


\paragraph{Fonctionnalités optionnelles}
Nous voulons ajouter la possibilité de déposer son rapport en ligne et la communication par Facebook.\newline
\includegraphics[scale=0.5]{usecase3.jpg}\newline
\subsection{Conclusions}

Après notre analyse, nous avons choisi d'utiliser un framework pour créer le site, et donc de tout refaire. Nous avons fait ce choix car, après plusieurs années de modification, nous ne pouvions pas reprendre le code d'origine.\\ De plus, nous voulions centraliser les technologies, pour avoir moins de choses à gérer séparément.\\ 
Nous avons choisi Symfony2 car il est de plus en plus utilisé dans le monde du web et nous permet de garder la majorité des technologies du site d'origine. Nous continuerons à utiliser MySQL, PHP, HTML et CSS.\\ 
Propel sera remplacé par Doctrine, pour des raisons de pérennité de Symfony2.\\Symfony nous permettra aussi la mise en œuvre de Facebook sur le site.


\section{Rapport technique}
% Histoire du site

\subsection{Conception}
% Explication Symfony, doctrine, Bootstrap
\subsubsection{Apports technologiques}
Voici une présentation des nouveautés.\newline
\begin{enumerate}


\item \textbf{Symfony} : c'est un framework (boîte à outils) \textbf{MVC} (Modèle-Vue-Contrôleur) libre écrit en \textbf{PHP5}. Il nous permet de regrouper le PHP, l'ORM et le HTML,CSS, ce qui simplifie la maintenance du code et les modifications.
L'ORM utilisé est \textbf{Doctrine}.
Symfony nous permet de faciliter notre travail de groupe, le travail étant découpé en dossier et sous-dossier, comme on le montrera plus loin.
Il gère également seul l'architecture \textbf{MVC} en séparant le \textbf{PHP} du \textbf{HTML}.\newline

  Les atouts de Symfony :
  \begin{itemize}
  \item le code est découplé;
  \item la séparation application / module permet de personnaliser facilement de nombreux paramètres;
  \item meilleure lisibilité du code;
  \item une API;
  \item des feuilles de résumé (cheat sheets);
  \item importante communauté d'utilisateurs et tutoriels de référence.\newline
  \end{itemize}

Petit rappel sur le MVC, qui est la base de l'organisation de Symfony : c'est un modèle d'architecture qui sépare vue, contrôleur et modèle.\\ C'est lui qui permet à une personne de travailler sur la vue pendant qu'une autre travaille sur le contrôleur.
\begin{itemize}
\item Modèle : génère les données et le contenu.
\item Vue : affiche les pages.
\item Contrôleur : génère les réponses aux requêtes.
\end{itemize}
\includegraphics[scale=0.4]{mvc.png}\newline 

Voici un diagramme de séquence montrant la communication des différentes parties pour la fonction AjouterUtilisateur(), qui ajoute un utilisateur en base de donnée. Vous avez ici un exemple avec AjouterUtilisateur(), mais le schéma est le même pour toutes les fonctions.\newpage
\includegraphics[scale=0.5,angle=90,width=15cm,height=14cm]{diag.jpg}
\newpage
\item \textbf{Bootsrap}: Bootsrap est un framework qui nous permet d'avoir une vue esthétique.On peut l'installer facilement dans Symfony, il est utiliser dans les fichiers de vues.
\item \textbf{Doctrine} :  il s'agit d’un \textbf{ORM} (object-relational mapping) pour \textbf{PHP5}. Un \textbf{ORM}  est une technique permettant de lier un ensemble de classes objet à une base de données relationnelle. Il peut s'utiliser avec Symfony et \textbf{Symfony2}. Nous l'avons choisi au détriment de Propel car celui ci est amené à disparaître dans les prochaines versions de Symfony.\newline
\end{enumerate}
\subsubsection{Descriptions et code}

La conception d'un site avec Symfony se fait obligatoirement avec des bundles. Les bundles sont des "briques" qui correspondent à des regroupements de fonctionnalités du site.\\

Nous avons donc définis cinq bundles :
\begin{itemize}
\item Soutenance : pour gérer les dates de soutenance, noter et afficher les notes et les rapports
\item Projet : pour gérer les projets
\item Utilisateurs : pour gérer les utilisateurs
\item Admin : pour gérer les fonctionnalités de l'administrateur
\item General : gère la vue de l’accueil pour les personnes non authentifiées ou étant anonyme.
\end{itemize}
Nous avons choisi ces bundles pour respecter la définition d'un bundle qui demande qu'un bundle soit indépendant des autres.\\

La \textbf{base de données} avec Symfony est gérée par Doctrine. Il fallait donc concevoir une base de données composer "d'objets".
Pour respecter la forme d'utilisation, chaque table est rangée dans un bundle, celui qui lui convient le mieux, et elle porte le nom d'\textbf{entité}.\\

Par ailleurs, il faut savoir qu'en plus de notre bundle Utilisateur, nous avons un FOSUserBundle, qui est un bundle "classique" contenant les fonctionnalités de base d'un utilisateur, crée par la communauté de Symfony.\\
Il faut cependant le configurer pour l'adapter à notre site.
%%Expliquer comment il agi dans le site

Nous allons décrire le contenu des bundles.
Chaque bundle contient plusieurs dossiers. Ceux que nous utilisons sont les dossiers :
\begin{itemize}
\item Controller, qui contient des fichiers .php qui contiennent les fonctions du bundle.
\item Resources, qui contient les fichiers twig (la vue)
\item Entity, qui sont les entités qu'on génére pour la BDD (les tables au-dessus)\newline
\end{itemize} 

\begin{enumerate}
\item \textbf{GeneralBundle}\newline
Ce bundle contient les contrôleurs permettant d’afficher une vue pour les utilisateurs identifiés anonymement ou une vue modifiée pour les utilisateurs identifiés avec les rôles ROLE\_ USER, ROLE\_ SECRETAIRE, ROLE\_ TUTEUR ou ROLE\_ ADMIN(cf. partie sécurité).\newline
Il permet de gérer l’affichage de la page d’accueil du site, il contient un contrôleur unique “DefaultController” contenant la fonction ”indexAction()”.\newline
Son rôle est d'aller chercher dans la base de donner tous les projets et de les afficher.
Si l'utilisateur est un administrateur, il peut également supprimer ou modifier des projets sur cette page.
Le fichier Twig teste le statut de l'utilisateur et fait l'affichage des données renvoyées par indexAction().\\
Voir le code du fichier DefaultController en annexe.
\newpage


Vue d'utilisateur non connecté : \newline \newline
\includegraphics[scale=0.3]{not_logged.png}\newline
Vue de la page en mode admin : \newline \newline
\includegraphics[scale=0.3]{logged_admin.png}\newline \newline







\item \textbf{FOSUserBundle}\newline

Une des fonctionnalités principales qu’offre un site web est la possibilité de s'authentifier.\\
Il existe plusieurs méthodes afin de réaliser cela(HTTP, SESSION, COOKIES, etc).\newline
Symfony utilise un système de sécurité basé sur une authentification HTTP et des rôles, toutes les configurations sont écrites dans le fichier app/config/security.yml(voir ci dessous).
\newpage
\begin{verbatim}
//app/config/security.yml

security:
    encoders:
        Symfony\Component\Security\Core\User\User: plaintext
        Site\UtilisateurBundle\Entity\Utilisateur : sha512

    role_hierarchy:
        ROLE_TUTEUR : ROLE_USER
        ROLE_SECRETAIRE :   [ROLE_TUTEUR, ROLE_USER]
        ROLE_ADMIN: [ROLE_USER, ROLE_TUTEUR, ROLE_SECRETAIRE]
        ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH, ROLE_TUTEUR, ROLE_SECRETAIRE]

    providers:
        main :
            id : fos_user.user_provider.username

    firewalls:
        dev:
            pattern:  ^/(_(profiler|wdt)|css|images|js)/
            security: false

        main :
            pattern : ^/
            anonymous : true
            provider :  main
            form_login :
                login_path :    site_homepage
                check_path :    fos_user_security_check
            logout :
                path :  fos_user_security_logout
                target : /
            remember_me:
                key:    %secret%

    access_control:
        - {path : ^/tuteur, role : ROLE_TUTEUR}
        - {path : ^/admin, role : ROLE_ADMIN}
        - {path : ^/secretaire, role : ROLE_SECRETAIRE}
        - {path : ^/projet, role : ROLE_TUTEUR}
        - {path : ^/register, role : ROLE_ADMIN}
        - {path : ^/soutenance, role : ROLE_ADMIN}

\end{verbatim}

Nous pouvons dans un premier temps voir la partie “encoders” qui correspond à la méthode de 
cryptage du mot de passe que va employer Symfony.\\
La section ROLE\_HIERARCHIE représente des rôles sous forme d’héritage qui sont en réalité 
des droits d’accés que l’on fera correspondre aux différentes sections du site.\\
Providers correspond aux entité à récupérer pour l’authentification. 
Le pare feu "firewalls" permet de paramétrer les donnés à utiliser lors d’une tentative d'accès à 
une page nécessitant une connexion.\\
On peut voir qu’on utilise le provider déclaré au dessus, et des contrôleurs vers lesquels rediriger 
dans le cas où l'on ne serait pas connecté ou que l’on souhaitera se déconnecter.\newline 
Ensuite vient la partie “acces\_ control” qui indique, une fois authentifié sur le site, les droits 
d'accès.\newline

Afin de gérer au mieux les utilisateurs (authentification, inscription, changement de mot de passe,etc),nous avons pris la décision d'utiliser le FOSUserBundle.\\ En effet la communauté Symfony étant grande,il existe de nombreux bundles prêt à l'emploi et dont le code est opensource.\\

Le FOSUserBundle nous permet de gérer, d’une part, les formulaires de login, d’inscription, de changement de données nous appartenant, de changement de mot de passe, d'autre part de l’affichage de nos données personnelles, et du déconnexion.\newline 
Cependant, certaines parties des contrôleurs et des vues de ce bundle ont dû être modifiés comme l’ajout de ces deux fonctions dans le fichier RegistrationController.php qui sert à l’inscription :
\newpage

\lstinputlisting[language=PHP]{RegistrationController.php}

Elles nous permettent de donner des rôles différents selon le type d’utilisateur à créer(étudiant, tuteur, etc).\\
Elles sont appelées depuis la fonction registerAction() de ce même contrôleur :

\begin{verbatim}
$type=$request->get("type");
$this->modifierType($type,$user,$request); 
\end{verbatim}

Voir le register\_content.html.twig, en annexe.\newline
D’autres vues ont également été modifié comme \textbf{login.html.twig} qui affiche le formulaire de connexion ou des liens pour la personne authentifée : 

\begin{verbatim} 
{% trans_default_domain 'FOSUserBundle' %}

{% block fos_user_content %}
{% if error %}
    <div>{{ error|trans }}</div>
{% endif %}

{% if app.user %}

    <li class="dropdown-header">Mon compte</li>
    <li><a href="{{path('fos_user_profile_show')}}">Consulter ses informations</a>
    <li><a href="{{path('fos_user_profile_edit')}}">Modifier ses informations</a>
    <li><a href="{{path('fos_user_change_password')}}">Modifier son mot de passe</a>
    <li><a href="{{path('fos_user_security_logout')}}">Se déconnecter</a></li>
{% else %}
<form action="{{ path("fos_user_security_check") }}"
 method="post" roles="form" class="form col-md-11">
    <input type="hidden" name="_csrf_token" value="{{ csrf_token }}" />

    <div class="form-group">
        <label for="username">Nom d'utilisateur :</label>
        <input type="text" id="username" name="_username" 
        value="{{ last_username }}" 
        required="required" class="form-control" />
    </div>
    <div class="form-group">
        <label for="password">Mot de passe</label>
        <input type="password" id="password" name="_password" 
        required="required" class="form-control" />
    </div>
    <div class="checkbox">
        <input type="checkbox" id="remember_me" name="_remember_me" value="on" />
            <label>
                <input type="checkbox" id="remember_me" name="_remember_me"
                 value="on" />
                Se souvenir de moi
            </label>
    </div>
<p>
    <button type="submit" class="btn btn-success">Se connecter</button>
</p>
</form>
{% endif %}
{% endblock fos_user_content %}
\end{verbatim}

\textbf{show.html.twig} qui permet d’afficher les informations personnelles de l’utilisateur: 
\begin{verbatim}
{% extends "::layout.html.twig" %}

{% block body %}
{% block fos_user_content %}
<div style="margin-top :25px;">
    {% include "FOSUserBundle:Profile:show_content.html.twig" %}
</div>
{% endblock fos_user_content %}
{% endblock %}
\end{verbatim}
 
\textbf{edit\_content.html.twig} qui affiche le formulaire permettant de modifier certaines infos : 
\begin{verbatim}
{% trans_default_domain 'FOSUserBundle' %}

<form action="{{ path('fos_user_profile_edit') }}" {{ form_enctype(form) }} 
method="POST" class="fos_user_profile_edit">
    <div class="form-group">
        {{form_label(form.username)}}
        {{form_errors(form.username)}}
        {{form_widget(form.username,
         {'attr' : {'class':'form-control'}})}}
    </div>
    <div class="form-group">
        {{form_label(form.email)}}
        {{form_errors(form.email)}}
        {{form_widget(form.email, 
        {'attr' : {'class':'form-control'}})}}
    </div>
    <div class="form-group">
        {{form_label(form.current_password)}}
        {{form_errors(form.current_password)}}
        {{form_widget(form.current_password, 
        {'attr' : {'class':'form-control'}})}}
    </div>
    <div>
        <button type="submit" class="btn btn-success">
        {{ 'profile.edit.submit'|trans }}</button>
    </div>
</form>
\end{verbatim}

Le fichier \textbf{changePassword\_content.html.twig} qui permet d’afficher le fomulaire de modification de mot de passe : 

\begin{verbatim} 
{% trans_default_domain 'FOSUserBundle' %}

<form action="{{ path('fos_user_change_password') }}"
 {{ form_enctype(form) }} method="POST" class="fos_user_change_password">
    <div class="form-group">
        {{ form_label(form.current_password) }}
        {{ form_errors(form.current_password) }}
        {{ form_widget(form.current_password, 
        {'attr' : {'class' : 'form-control'}}) }}
    </div>
    <div class="form-group">
        {{ form_label(form.plainPassword.first) }}
        {{ form_errors(form.plainPassword.first) }}
        {{ form_widget(form.plainPassword.first,
         {'attr' : {'class' : 'form-control'}}) }}
    </div>
    <div class="form-group">
        {{ form_label(form.plainPassword.second) }}
        {{ form_errors(form.plainPassword.second) }}
        {{ form_widget(form.plainPassword.second, 
        {'attr' : {'class' : 'form-control'}}) }}
    </div>

    {{form_rest(form)}}
    <button type="submit" class="btn btn-success">
    {{ 'change_password.submit'|trans }}</button>
</form>
\end{verbatim}
Pour rendre compatible notre utilisateur avec le FOSUserBundle, nous avons du faire hériter notre entité Utilisateur de celle du FOSUserBundle.\\
On a dû également mettre chaque attribut en “protected” et non pas en “private”. 
Certains attributs existent déjà dans le User du FOSBundle : username, email, password, id, etc. 
Ce fichier présente l’entité Utilisateur compatible avec le Bundle. 
\newpage
\lstinputlisting[language=PHP]{Utilisateur.php}
On a créé un formulaire modifié permettant de s’ajouter à celui du FOSUser :  
\lstinputlisting[language=PHP]{UtilisateurType.php}
Et pour finir notre bundle a dû “hérité” de celui du FOSUserBundle “SiteUtilisateurBundle.php : 
\lstinputlisting[language=PHP]{SiteUtilisateurBundle.php}
Configuration du FOSUserBundle dans app/config/config.yml : 
\begin{verbatim}

fos_user:
    db_driver:     orm    # Le type de BDD à utiliser, nous utilisons l'ORM Doctrine 
                             depuis le début
    firewall_name: main   # Le nom du firewall derrière lequel 
                            on utilisera ces utilisateurs
    user_class:    Site\UtilisateurBundle\Entity\Utilisateur 
                        # La classe de l'entité User que nous utilisons

    registration:
        form:
            type: site_utilisateur_inscription

\end{verbatim}


  
\item \textbf{AdminBundle}
Ce bundle contiendra les contrôleurs permettant d’afficher les vues pour les fonctionnalités de la partie administrateur.\\
Il contiendra 2 classes de contrôleur : “DefaultController”, "GestionController”.\newline

\textbf{DefaultController : }\newline
\begin{itemize}
\item \textbf{indexAction()} : retourne une vue affichant les fonctions que l’on peut faire
\item \textbf{mailTousTuteurAction()} : permet d’envoyer un mail à tous les tuteurs d'après la BDD en utilisant le services mail de Symfony
\item \textbf{trombinoscope()} : gère et retourne la vue d’un trombinoscope en fonction des inscrits dans la BDD
\item  \textbf{phaseAction(\$ue)} : gère l'envoi de mail selon les phases avancées des projets.\newline
\end{itemize}


\textbf{GestionController :}\newline
\begin{itemize}
\item \textbf{inscriptionAction()} : permet d’insérer, ou de supprimer un utilisateur en vérifiant le rôle de l’utilisateur en question
\item \textbf{modifEtudiantAction()} : permet l’ajout, la modification, suppression d’un étudiant
\item \textbf{supprimerUtilisateurAction(\$id)}
\item \textbf{supprimerUtilisateurId(\$id, \$donnees)} :suppression avec affichage de données
\item \textbf{ajouterEtudiantAction()} : ajouter des étudiants en lisant ligne par ligne un fichier Csv contenu dans une classe Csv.php
\item \textbf{remplirCsv(\$request)} : reçoit des données de formulaire et retourne un objet Csv avec le fichier, l'ordre des variables, le délimiteur etc.
\item \textbf{sauverBDDAction()}\newline
\end{itemize}


\textbf{Routage :}\newline
\begin{verbatim}
  SiteAdminIndex :
  pattern : \admin\{page}
    defaults : {_controller : SiteAdminBundle:Default:index}
    requirements :
    page : (|index.html|index.php)

    SiteAdminMailTousTuteur :
    pattern : \admin\mail
    defaults : {_controller : SiteAdminBundle:Default:mail}

    SiteAdminInscription :
    pattern : \admin\inscription
    defaults : {_controller : SiteAdminBundle:Gestion:inscription}
    requirements :

    SiteAdminModifEtudiant :
    pattern : \admin\modifEtudiant\
    defaults : {_controller : SiteAdminBundle:Gestion:modifEtudiant}

    SiteAdminphase :
    pattern : \admin\phase
    defaults : {_controller : SiteAdminBundle:Gestion:phase}
    
    projet_site_ajouter_etudiant_csv :
    pattern : /admin/ajouter-etudiant/csv
    defaults : {_controller : SiteAdminBundle:Gestion:ajouterEtudiant}
    
    projet_site_modifier_etudiant :
    pattern : /admin/modifier-etudiant/
    defaults : {_controller : SiteAdminBundle:Gestion:modifierEtudiant}

    projet_site_supprimer_utilisateur :
    pattern : /admin/supprimer-utilisateur/{id}
    defaults : {_controller : SiteAdminBundle:Gestion:supprimerUtilisateur}
    requirements :
        barre : (|/)
        id : (|\d+)
\end{verbatim}
Afin d’ajouter des étudiants grâce à un fichier CSV, nous avons défini une route pour une fonction à cet usage.\\
Les "requirements" sur le routage permettent de spécifier le type de paramètre demandé.\\ "pattern" désigne la route correspondante de l'URL. \\"defaults" donne la route de la fonction à appeler.\\ Voici un exemple de fichier de vue pour ce bundle. Il s'agit de la vue pour gérerPhase(), qui selon les phases d'avancé de l'Ue, envoie des mails différents.
  
\begin{verbatim}
{# src/Site/AdminBundle/Resources/views/Gestion/gererPhase.twig.html #}
{% extends "::layout.html.twig" %}

{% block title %}
Gérer Phase - {{ parent() }}
{% endblock %}


{% block body %}

	{#le titre#}
	<h2 style="text-align:center" class="sub-header">Gérer les phases</h2>
	<div class="jumbotron">
	{%if afficher %}
		<div class="alert alert-{{alerte}}">
			{{flash}}
		</div>
	{%endif%}
	 <p><a class="btn btn-lg btn-warning" href="?ue=l2" role="button">Phase pour L2</a>
	<a class="btn btn-lg btn-success" href="?ue=l3" role="button">Phase pour L3</a></p>
	</div>
	{#Le tableau avec les étapes#}
	<div class="table-responsive">
		<form name="formPhase" method="post" action="{{urlFormulaire}}">
		<table class="table table-striped">
		<tr>
			<th>numéro</th>
			<th>Phase de gestion</th>
			<th>Action</th>
		</tr>	
			{#Etape 1: mail aux tuteurs puis dépôt de projet par les tuteurs#}
			
		<tr>
			<td>1</td>
			<td>mail aux tuteurs puis dépôt de projet par les tuteurs</td>
			<td>
			<input type="submit" value="Envoyer mail !" name="mailRechercheTuteur" />
			</td>
			</tr>
			{# phase 2 : insérer les etudiants dans la BD 
			---------------------------------------------#}
			<tr>
				<td>2</td>
				<td>importer les inscrits administratifs depuis l'ENT, annuaire,
				 L3 mention info, L3 Math Math info 
				 <a href="http://portail.univ-montp2.fr">ICI</a> 
				 vers un tableur (excel|spreadsheet) en ajoutant une colonne constante ia_code 
				 correspondant à leur Insc. 
				 Admin. : L2Info=FLINv701, L3Info=FLINv702, L3MathMI=FLMAv702  enregistrer 
				 sous csv avec séparateur ";"
				 importer dans la table etul2l3 de la bd meynardprojetinfol3 
				 par phpMyAdmin (Attention à indiquer la liste des colonnes : numetu,prenom,nom,email)
				
			 <code>insert into utilisateur(nom, prenom, login, password, email, type) 
				   select nom, prenom, numetu, md5(numetu), email, "e" 
				   from etudiantl2l3;</code>
				<code>insert into etudiant(id, ue_id, numetu, ia_code) 
				    select id, "l3", numetu, ia_code 
				    from utilisateur u, etudiantl2l3 e 
				    where u.login=e.numetu and ia_code="FLINv702";
				   </code>
				<code>insert into etudiant(id, ue_id, numetu, ia_code) 
				      select id, "l2", numetu, ia_code 
				      from utilisateur u, etudiantl2l3 e 
				      where u.login=e.numetu and ia_code=FLINv701";
				  </code>
				<code>insert into etudiant(id, ue_id, numetu, ia_code) 
				      select id, "l3", numetu, ia_code 
				      from utilisateur u, etudiantl2l3 e 
				      where u.login=e.numetu and ia_code="FLMAv702";
				 </code>
				</ul></td>
				<td>
				Phase manuelle !
				</td>
			</tr>
			{# phase 3 : avertir les étudiants
			----------------------------------------------#}
			<tr>
				<td>3</td>
				<td>Avertir les étudiants</td>
				{#faire le mail et bouton pour envoyer#}
				<td><input type="submit" value="Envoyer mail !" name="mailAvertirEtudiant" /></td>
			</tr>
			
			{# phase 4 : permettre les voeux des étudiants
			----------------------------------------------#}
			<tr>
				<td>4</td>
				<td>permettre les voeux des étudiants</td>
				<td><input type="submit" value="Activer les voeux !" name="activerVoeux" /></td>
			</tr>
			{# phase 5 : avertir les étudiants pour qu'ils fassent leurs voeux
			----------------------------------------------#}
			<tr>
				<td>5</td>
				<td>Faites vos voeux !</td>
				<td><input type="submit" value="Envoyer mail !" name="mailAvertirPourVoeux" /></td>
			</tr>
			{# phase 6 : manuel : affectation
			----------------------------------------------#}
			<tr>
				<td>6</td>
				<td>affecter les étudiants aux projets en faisant attention aux L2 PEIP 
				    de groupes de td différents</td>
				<td>Phase manuelle !</td>
			</tr>
			{# phase 7 : démarrer le travail
			----------------------------------------------#}
			<tr>
				<td>7</td>
				<td>démarrer les projets !</td>
				<td><input type="submit" value="Envoyer mail !" name="mailDemarrerProjet" /></td>
			</tr>
			{# phase 8 : cahier des charges
			----------------------------------------------#}
			<tr>
				<td>8</td>
				<td>cahier des charges !</td>
				<td><input type="submit" value="Envoyer mail !" name="mailCahierDesCharges" /></td>
			</tr>
			{# phase 9 : manuel : soutenances
			----------------------------------------------#}
			<tr>
				<td>9</td>
				<td>définir les plages de soutenances et réserver les salles</td>
				<td>Phase manuelle !</td>
			</tr>
			{# phase 10 :  mail aux tuteurs pour soutenances
			----------------------------------------------#}
			<tr>
				<td>10</td>
				<td>mail aux tuteurs pour soutenances</td>
				<td><input type="submit" value="Envoyer mail !" name="mailTuteurSoutenance" /></td>
			</tr>
			{# phase 11 : sauver BD
			----------------------------------------------#}
			<tr>
				<td>11</td>
				<td>sauver la BD</td>
				<td>Manuel PhpMyAdmin !</td>
			</tr>
			{# phase 12 :  supprimer souhaits et étudiants
			----------------------------------------------#}
			<tr>
				<td>12</td>
				<td>supprimer étudiants</td>
				<td><input type="submit" value="Supprimer les souhaits et les étudiants !" 
				        name="supprEtudiants" /></td>
			</tr>
		</table>
		</form>
	</div>



\end{verbatim}

\item \textbf{UtilisateurBundle}\newline
%formulaire
Ce bundle sert surtout pour l'ORM. Il possède un formulaire simple qui hérite de la classe formulaire du FOSUserBundle, il rajoute deux champs à ceux déjà présent : nom, prénom. Son contrôleur ne contient qu'une fonction, mais il possède deux entités importantes : Utilisateur, Etudiant. Les entités sont les "objets" du modèle de la base de données.\\Il a aussi une classe UtilisateurRepository, qui contient des requêtes que nous avons créées pour pouvoir les réutiliser dans les fonctions du contrôleur(cf annexe).\newline 


\textbf{DefaultController :}
\begin{itemize}
\item \textbf{indexAction()} : page d’accueil permettant de s’inscrire ou de se connecter.\newline
\end{itemize}
\textbf{Routage}:
\begin{verbatim}
 site_utilisateur_homepage:
    pattern:  /hello/{name}
    defaults: { _controller: SiteUtilisateurBundle:Default:index     }
\end{verbatim}\newline \newline





\item \textbf{ProjetBundle}\newline
Ce bundle contient les fonctions relatives aux projets ainsi que l'entité Projet. Cette dernière possède tous les champs d'un projet(cf.documentation). Il y a deux classes de contrôleur : “GestionController”, “DefaultController”.\newline

\textbf{DefaultController} :\newline
\begin{itemize}
\item \textbf{supprimerProjetAction(\$id)} : pour l'administrateur
\item \textbf{ajouterProjetAction()} : pour les tuteurs ou administrateurs
\item \textbf{modifierProjetAction(\$id)} : pour l'admin, éditer un projet 
\item \textbf{modifSouhaitAction()} : permet de faire sa liste de voeux.\newline
\item \textbf{affectationSouhaitAction()} : affectation manuelle des étudiants
\item \textbf{affectationAutoAction()} : affectation automatique des étudiants
\end{itemize}

\textbf{GestionController} :\newline
\begin{itemize}
\item \textbf{affectationManuelleAction(\$id)}
\item \textbf{affecterEtudManuAction(\$id)}
\item \textbf{supprimerAffectationAction(\$id, \$idProjet)}\newline
\end{itemize}
\textbf{Routage} :\newline
\begin{verbatim}
  SiteProjetEmargement :
  pattern : /projet/emarge
  defaults : {_controller : SiteProjetBundle:Default:listeEmarge}

  SiteProjetAffectation :
  pattern : /projet/affectation
  defaults : {_controller : SiteProjetBundle:Default:listeAffectation}

  SiteProjetListeProjet :
  pattern : /projet/listeProjet
  defaults : {_controller : SiteProjetBundle:Default:listeProjet}

  SiteProjetSupprimer :
  pattern : /projet/supprimer
  defaults : {_controller : SiteProjetBundle:Default:supprimer}

  SiteProjetAjout :
  pattern : /projet/ajout
  defaults : {_controller : SiteProjetBundle:Default:ajout}

  SiteProjetmodif :
  pattern : /projet/modif/{id}
  defaults : {_controller : SiteProjetBundle:Default:modif}
  requirements :
  id : (|\d)

\end{verbatim}

\item \textbf{SoutenanceBundle}\newline
Ce bundle contient les contrôleurs relatifs aux fonctions de soutenance. L'entité sera une entité Soutenance.\newline

\textbf{GeneralControlleur} :\newline
\begin{itemize}
\item \textbf{ajouterSoutenanceAction(\$id)}: pour ajouter une soutenance
\item \textbf{indexAction()}: donne la liste des soutenances
\end{itemize}

\textbf{Routage} :
\begin{verbatim}
 site_projet_planning:
    pattern:  /planning
    defaults: { _controller: SiteSoutenanceBundle:Default:index }

site_projet_soutenance_ajouter:
    pattern:  /admin/ajouter-modifier-soutenance/{id}
    defaults: { _controller: SiteSoutenanceBundle:Default:ajouterSoutenance }

\end{verbatim}
\item FacebookBundle
Le FacebookBundle est dédié à l'ajout de la fonctionnalité supplémentaire concernant la communication entre élèves.\\
Ce bundle, que nous avons crée, est configuré en tant que service, mais il ne laisse aucune persistance des données.\\ C'est-à-dire qu'en base de données, il n'y a aucune informations enregistrées (noms, photos,...).\\
BaseFacebook, le sdk PHP, est en relation avec une application Facebook crée et administrée par un utilisateur FacebookDeveloper. Le sdk est interne au FacebookBundle.\\
C'est un bundle qui fait de la gestion de flux : tout est stocké par Facebook.\\
Nous avons fait ce choix car M.Meynard ne voulait pas avoir à modérer l'application sociale. Ici, c'est Facebook qui est responsable du contenu des échanges des utilisateurs. 
Une explication détaillée ainsi qu'un tutoriel de configuration de l'application Facebook sont disponibles sur le site, dans la partie Help, dans la partie administration Facebook.\newline
Voici un extrait de fonction d'appel d'API. Il comporte une instance de la classe BaseFacebook configurée  pour notre application Facebook. On effectue un appel d'API via cette instance grâce à la méthode api(). On relève les exceptions d'API via l'instance de classe de FacebookApiException.
\begin{verbatim}
//Groups de l'application
  public function getGroupsApp(BaseFacebook $facebook){
    try{
      $app_groups = $facebook->api("app/groups",'GET');
      return $app_groups;
    }catch (FacebookApiException $e){
      $this->ExCatch($e,$facebook);
    }
    return 0;
  }
\end{verbatim}
Ce contrôleur a le même schéma qu'un contrôleur Symfony2 classique. La fonction instancie  un service de BaseFacebook, via le fichier de configuration du bundle, qui nous servira à récupérer les informations nécessaire au fonctionnement des API ainsi qu'au niveau de permission requis. Le contrôleur va organiser l'information récupérer via le GraphAPI Facebook et les transmettre à la vue souhaitée.  Un contrôleur est affecté à chaque vue. 
\begin{verbatim}
//MessageAction
  public function messageAction(Request $request)
  {
    $facebook = $this->get('fos_facebook.api');
    $groups = $this->getGroupsApp($facebook);
    $group = $this->getFeedAppGroup($groups['data'][0]['id'],$facebook);
      
    $uid= $facebook->getUser();
    $message=$request->request->get('message');

    $test=$facebook->api($groups['data'][0]['id']."/feed","POST",array('message' => $message ));//ID group static !!!!! TODO

    /* return $this->render('SiteFacebookDisplayBundle:Default:index.html.twig', array('test'=>$test ));*/
    return $this->redirect($this->generateUrl('fb/test'));
  }
\end{verbatim}

\end{enumerate}
\subsection{Services}
A propos des services, nous avons utilisé SwiftMail, qui est un service de Symfony, pour toutes les fonctions d'envoi de mail. Pour l'utiliser, il faut configurer les fichiers config.yml et parameters.yml.\\
Dans config\_dev.yml, on configure :\\
swiftmailer:
    transport: gmail
    username:  exemple@gmail.com
    password:  xxx\newline


Dans parameters.yml, on indique notre adresse mail:\\
mailer\_user: exemple@gmail.com


\subsection{Résultats}
Nous avons construit un site qui respecte le cahier des charges. Il est fonctionnel, agréable et intuitif. Le code est propre, uniforme, facile à améliorer.\\ Nous avons rajouté la partie Facebook proposée dans le cahier des charges. C'est une amélioration qui proposera un moyen de communication entre étudiants, sous le contrôle du tuteur.\newline
Voici des vues du site. Des vues de Facebook :\newline
\includegraphics[scale=0.4]{vueFacebook1.jpg}\newline \newline
\includegraphics[scale=0.4]{vueFacebook2.jpg}\newline
\newpage
Quelques fonctionnalités :\newline \newline
\includegraphics[scale=0.3]{mail_tous_tuteurs.png}\newline
\includegraphics[scale=0.3]{planning.png}\newline
\includegraphics[scale=0.3]{gerer_phases.png}\newline
\includegraphics[scale=0.3]{ajouter_projet.png}\newline
\newpage
Vue de tuteur connecté :\newline \newline
\includegraphics[scale=0.3]{logged_tuteur.png}\newline

Ajout d'un étudiant avec un fichier csv :\newline \newline
\includegraphics[scale=0.3]{ajouter_etudiant_csv.png}\newline
\subsection{Perspectives de développement}
Pour l'amélioration du site, nous proposons de continuer à améliorer la partie communication pour les étudiants, car de nombreux groupes ont des problèmes de communication ou de technologies non adaptées. Le FacebookBundle peut être améliorer.

\section{Rapport d'activité}
 
\subsection{Organisation du travail}
Étant donné le nombre important d’étudiants dans notre projet, il est important de prévoir une bonne stratégie afin de se répartir le travail de manière efficace.\\
Pour ce qui est de la communication, dans un contexte toujours informel, nous nous donnions rendez-vous verbalement lorsque nous en avions la possibilité. Cependant, afin de centraliser nos communications, nous avons créer un groupe privé (seuls les membres du groupe ont un accès) sur le réseau social “Facebook”.\\ Ainsi, chaque rendez-vous est organisé sur un fil de conversation, ainsi que les feed-backs des réunions. Il est possible bien entendu de poser une question afin que tout le monde puisse profiter des réponses, et de donner son point de vue, de partager des fichiers, etc.\\
Après une analyse de la dernière version du projet, nous avons divisé le travail en tâches sur un fichier GoogleDoc, sur le Drive, afin d’avoir une vision d’ensemble structurée.\\ Nous leurs avons attribué une certaine durée, après quelques spéculations.\\
Voici donc le tableau exprimant ces tâches et leurs temps de réalisation :
\includepdf[pages=1-3]{diaggantt.pdf}
\subsubsection{Les débuts}

Bien sûr, il n'a pas été scrupuleusement respecté. Nous avons commencé par mettre en œuvre le "cadre", c'est-à-dire créer les bundles de Symfony, et défini une norme pour l'écriture des fonctions et des routes.\\
Nous avons mis en place le FOSUserBundle. Pour ce bundle, déja existant sur le site friendsofsymfony.com, il fallait configurer, c'est à dire l'adapter à nos besoins.
Parallèlement, nous avons commencé à travailler sur la vue, c'est-à-dire le visuel de notre site. Il fallait designer le site sur un layout.html.twig qui sera hérité par toutes les vues.
Ces début prirent du temps, mais ne posèrent pas trop de problème.\\
De plus, dès le lancement, nous apprenions chacun de notre coté, mais en se tenant au courant, l'utilisation de Symfony. Cette étape nous a pris deux mois.\\
\subsubsection{Le codage et nos difficultés}
 Nous avions déterminé grâce à l'analyse les différentes fonctions qui existeraient dans chaque bundle. A partir de là, nous nous sommes réparti ces fonctions et nous avons commencé à coder. Nous avons eu différents problèmes :\\
 \begin{itemize}
 \item Symfony : c'est un outil puissant, qui offre de nombreuses possibilités, que nous ne connaissions pas. Les débuts ont été laborieux.
 \item SwiftMail : la configuration pour recevoir les mails n'est pas toujours bien indiquée et elle a été souvent source d'erreur.
 \item Facebook : apprendre à utiliser une API et l'adapter à nos besoins et à notre site. D'autant plus, qu'une version supérieure de l'API a été mise en ligne quelques jours avant la soutenance.
 \item des problèmes de droits se sont posés, car Symfony ne nous donne pas toujours accès à tout.
 \item l'hébergeur est un problème: Symfony nécessite d'avoir les droits à la racine, ce qui n'est pas le cas des hébergeurs gratuits.
 \end{itemize}

\subsection{Sécurité}
La sécurité est principalement assurée par Symfony2, pour tout ce qui concerne les mots de passe et champs de formulaire.
Pour ce site, nous devions gérer des droits différents selon les utilisateurs (admin, étudiant, tuteur, secrétaire). C'est là que peut se poser le problème de sécurité. L'administrateur a tout les droits et toutes les données des utilisateurs. Cependant, Symfony nous a posé problème pour le droit de l'administrateur concernant les phases. 
\newpage
\section{Conclusion}

Pour conclure, nous pouvons dire que nous avons mené à bien notre projet, dans une bonne ambiance, durant ces quatre mois. Nous avons énormément appris d'un point de vue technique et personnel.\\D'une part, nous avons développé un site avec un framework que nous ne connaissions pas et que nous avons dû apprendre et maîtriser. Ce projet nous a également permis d’apprendre rapidement l’utilisation de nouvelles technologies comme l'utilisatoin du modèle MVC pour programmer, d'un ORM ainsi que du framework Symfony2.\\
D'autre part, nous avons acquis des connaissances au niveau de l'organisation qui nous a permis de mener à bien ce projet en travaillant en groupe mais aussi séparement.  Nous avons aussi progressé dans la responsabilité de chacun à travailler de manière autonome. Un travail de communication a donc été nécessaire : le Drive de Google et Facebook nous ont beaucoup aidé à ce niveau.\\
Nous vous souhaitons une bonne naviguation sur le site !
\newpage
\section{Documentation}

Vous trouverez ici des extraits de la documentation. Par soucis écologique, nous avons préféré mettre la totalité de la documentation en ligne, sur le site.
\subsubsection{FOSUserBundle}
\includepdf[pages=15-19]{FOSdoc.pdf}
\subsubsection{AdminBundle}
\includepdf[pages=15-22]{Admindoc.pdf}
\subsubsection{GeneralBundle}
\includepdf[pages=17-28]{Generaldoc.pdf}
\subsubsection{ProjetBundle}
\includepdf[pages=17-27]{Projetdoc.pdf}
\includepdf[pages=29]{Projetdoc.pdf}
\subsubsection{SoutenanceBundle}
\includepdf[pages=15-19]{Soutenancedoc.pdf}
\includepdf[pages=21]{Soutenancedoc.pdf}
\subsubsection{UtilisateurBundle}
\includepdf[pages=17-27]{Utilisateurdoc.pdf}
\includepdf[pages=29-30]{Utilisateurdoc.pdf}
\section{Annexe}

\lstinputlisting[language=PHP]{FBDefaultController.php}
\newpage
\begin{verbatim}
{register_content.html.twig}
{% trans_default_domain 'FOSUserBundle' %}
<div class="container" style="margin-top:25px;">
<div class="col-md-4 col-md-offset-3">
    <form action="{{ path('fos_user_registration_register') }}" {{ form_enctype(form) }}
     method="POST" class="fos_user_registration_register">
        {{form_errors(form)}}
        <div class="form-group">
            {{form_label(form.username)}}
            {{form_errors(form.username)}}
            {{form_widget(form.username, {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            {{form_label(form.email)}}
            {{form_errors(form.email)}}
            {{form_widget(form.email, {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            {{form_label(form.nom)}}
            {{form_errors(form.nom)}}
            {{form_widget(form.nom, {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            {{form_label(form.prenom)}}
            {{form_errors(form.prenom)}}
            {{form_widget(form.prenom, {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            {{form_label(form.plainPassword.first)}}
            {{form_errors(form.plainPassword.first)}}
            {{form_widget(form.plainPassword.first, 
              {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            {{form_label(form.plainPassword.second)}}
            {{form_errors(form.plainPassword.second)}}
            {{form_widget(form.plainPassword.second, 
               {'attr' : {'class' : 'form-control'}})}}
        <div>
        <div class="form-group">
            <label for="type">Type :</label>  
            <select class="form-control" name="type" id="type"
             onchange="afficherEtudiant(this);">
                <option value="u">Utilisateur non étudiant</option>
                <option value="t">Tuteur</option>
                <option value="e">Étudiant</option>
                <option value="s">Secrétaire</option>
            </select>
        </div>
        <div id="form-etudiant"></div>
        {{form_rest(form)}}
        <button type="submit" class="btn btn-success">Enregistrer</button>
    </form>
</div>
</div>



\end{verbatim}
\lstinputlisting[language=PHP]{GeneralDefaultController.php}
\lstinputlisting[language=PHP]{UtilisateurRepository.php}
\end{document}
